{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Configurations for Colab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "IN_COLAB = \"google.colab\" in sys.modules\n",
    "\n",
    "if IN_COLAB:\n",
    "    !apt install python-opengl\n",
    "    !apt install ffmpeg\n",
    "    !apt install xvfb\n",
    "    !pip install pyvirtualdisplay\n",
    "    from pyvirtualdisplay import Display\n",
    "    \n",
    "    # Start virtual display\n",
    "    dis = Display(visible=0, size=(400, 400))\n",
    "    dis.start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 06. Categorical DQN\n",
    "\n",
    "[M. G. Bellemare et al., \"A Distributional Perspective on Reinforcement Learning.\" arXiv preprint arXiv:1707.06887, 2017.](https://arxiv.org/pdf/1707.06887.pdf)\n",
    "\n",
    "The authors argued the importance of learning the distribution of returns instead of the expected return, and they proposed to model such distributions with probability masses placed on a discrete support $z$, where $z$ is a vector with $N_{atoms} \\in \\mathbb{N}^+$ atoms, defined by $z_i = V_{min} + (i-1) \\frac{V_{max} - V_{min}}{N-1}$ for $i \\in \\{1, ..., N_{atoms}\\}$.\n",
    "\n",
    "The key insight is that return distributions satisfy a variant of Bellman’s equation. For a given state $S_t$ and action $A_t$, the distribution of the returns under the optimal policy $\\pi^{*}$ should match a target distribution defined by taking the distribution for the next state $S_{t+1}$ and action $a^{*}_{t+1} = \\pi^{*}(S_{t+1})$, contracting\n",
    "it towards zero according to the discount, and shifting it by the reward (or distribution of rewards, in the stochastic case). A distributional variant of Q-learning is then derived by first constructing a new support for the target distribution, and then minimizing the Kullbeck-Leibler divergence between the distribution $d_t$ and the target distribution\n",
    "\n",
    "$$\n",
    "d_t' = (R_{t+1} + \\gamma_{t+1} z, p_\\hat{{\\theta}} (S_{t+1}, \\hat{a}^{*}_{t+1})),\\\\\n",
    "D_{KL} (\\phi_z d_t' \\| d_t).\n",
    "$$\n",
    "\n",
    "Here $\\phi_z$ is a L2-projection of the target distribution onto the fixed support $z$, and $\\hat{a}^*_{t+1} = \\arg\\max_{a} q_{\\hat{\\theta}} (S_{t+1}, a)$ is the greedy action with respect to the mean action values $q_{\\hat{\\theta}} (S_{t+1}, a) = z^{T}p_{\\theta}(S_{t+1}, a)$ in state $S_{t+1}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from typing import Dict, List, Tuple\n",
    "\n",
    "import gym\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from IPython.display import clear_output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Replay buffer\n",
    "\n",
    "Please see *01.dqn.ipynb* for detailed description."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    \"\"\"A simple numpy replay buffer.\"\"\"\n",
    "\n",
    "    def __init__(self, obs_dim: int, size: int, batch_size: int = 32):\n",
    "        self.obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.next_obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.acts_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.rews_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.done_buf = np.zeros(size, dtype=np.float32)\n",
    "        self.max_size, self.batch_size = size, batch_size\n",
    "        self.ptr, self.size, = 0, 0\n",
    "\n",
    "    def store(\n",
    "        self, \n",
    "        obs: np.ndarray, \n",
    "        act: np.ndarray, \n",
    "        rew: float, \n",
    "        next_obs: np.ndarray, \n",
    "        done: bool,\n",
    "    ):\n",
    "        self.obs_buf[self.ptr] = obs\n",
    "        self.next_obs_buf[self.ptr] = next_obs\n",
    "        self.acts_buf[self.ptr] = act\n",
    "        self.rews_buf[self.ptr] = rew\n",
    "        self.done_buf[self.ptr] = done\n",
    "        self.ptr = (self.ptr + 1) % self.max_size\n",
    "        self.size = min(self.size + 1, self.max_size)\n",
    "\n",
    "    def sample_batch(self) -> Dict[str, np.ndarray]:\n",
    "        idxs = np.random.choice(self.size, size=self.batch_size, replace=False)\n",
    "        return dict(obs=self.obs_buf[idxs],\n",
    "                    next_obs=self.next_obs_buf[idxs],\n",
    "                    acts=self.acts_buf[idxs],\n",
    "                    rews=self.rews_buf[idxs],\n",
    "                    done=self.done_buf[idxs])\n",
    "\n",
    "    def __len__(self) -> int:\n",
    "        return self.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Network\n",
    "\n",
    "The parametrized distribution can be represented by a neural network, as in DQN, but with atom_size x out_dim outputs. A softmax is applied independently for each action dimension of the output to ensure that the distribution for each action is appropriately normalized.\n",
    "\n",
    "To estimate q-values, we use inner product of each action's softmax distribution and support which is the set of atoms $\\{z_i = V_{min} + i\\Delta z: 0 \\le i < N\\}, \\Delta z = \\frac{V_{max} - V_{min}}{N-1}$.\n",
    "\n",
    "$$\n",
    "Q(s_t, a_t) = \\sum_i z_i p_i(s_t, a_t), \\\\\n",
    "\\text{where } p_i \\text{ is the probability of } z_i \\text{ (the output of softmax)}.\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Network(nn.Module):\n",
    "    def __init__(\n",
    "        self, \n",
    "        in_dim: int, \n",
    "        out_dim: int, \n",
    "        atom_size: int, \n",
    "        support: torch.Tensor\n",
    "    ):\n",
    "        \"\"\"Initialization.\"\"\"\n",
    "        super(Network, self).__init__()\n",
    "\n",
    "        self.support = support\n",
    "        self.out_dim = out_dim\n",
    "        self.atom_size = atom_size\n",
    "        \n",
    "        self.layers = nn.Sequential(\n",
    "            nn.Linear(in_dim, 128), \n",
    "            nn.ReLU(),\n",
    "            nn.Linear(128, 128), \n",
    "            nn.ReLU(), \n",
    "            nn.Linear(128, out_dim * atom_size)\n",
    "        )\n",
    "\n",
    "    def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        dist = self.dist(x)\n",
    "        q = torch.sum(dist * self.support, dim=2)\n",
    "        \n",
    "        return q\n",
    "    \n",
    "    def dist(self, x: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Get distribution for atoms.\"\"\"\n",
    "        q_atoms = self.layers(x).view(-1, self.out_dim, self.atom_size)\n",
    "        dist = F.softmax(q_atoms, dim=-1)\n",
    "        dist = dist.clamp(min=1e-3)  # for avoiding nans\n",
    "        \n",
    "        return dist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Categorical DQN Agent\n",
    "\n",
    "\n",
    "Here is a summary of DQNAgent class.\n",
    "\n",
    "| Method           | Note                                                 |\n",
    "| ---              | ---                                                  |\n",
    "|select_action     | select an action from the input state.               |\n",
    "|step              | take an action and return the response of the env.   |\n",
    "|compute_dqn_loss  | return dqn loss.                                     |\n",
    "|update_model      | update the model by gradient descent.                |\n",
    "|target_hard_update| hard update from the local model to the target model.|\n",
    "|train             | train the agent during num_frames.                   |\n",
    "|test              | test the agent (1 episode).                          |\n",
    "|plot              | plot the training progresses.                        |\n",
    "\n",
    "All differences from pure DQN are noted with comments *Categorical DQN*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DQNAgent:\n",
    "    \"\"\"DQN Agent interacting with environment.\n",
    "    \n",
    "    Attribute:\n",
    "        env (gym.Env): openAI Gym environment\n",
    "        memory (ReplayBuffer): replay memory to store transitions\n",
    "        batch_size (int): batch size for sampling\n",
    "        epsilon (float): parameter for epsilon greedy policy\n",
    "        epsilon_decay (float): step size to decrease epsilon\n",
    "        max_epsilon (float): max value of epsilon\n",
    "        min_epsilon (float): min value of epsilon\n",
    "        target_update (int): period for target model's hard update\n",
    "        gamma (float): discount factor\n",
    "        dqn (Network): model to train and select actions\n",
    "        dqn_target (Network): target model to update\n",
    "        optimizer (torch.optim): optimizer for training dqn\n",
    "        transition (list): transition information including\n",
    "                           state, action, reward, next_state, done\n",
    "        v_min (float): min value of support\n",
    "        v_max (float): max value of support\n",
    "        atom_size (int): the unit number of support\n",
    "        support (torch.Tensor): support for categorical dqn\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self, \n",
    "        env: gym.Env,\n",
    "        memory_size: int,\n",
    "        batch_size: int,\n",
    "        target_update: int,\n",
    "        epsilon_decay: float,\n",
    "        max_epsilon: float = 1.0,\n",
    "        min_epsilon: float = 0.1,\n",
    "        gamma: float = 0.99,\n",
    "        # Categorical DQN parameters\n",
    "        v_min: float = 0.0,\n",
    "        v_max: float = 200.0,\n",
    "        atom_size: int = 51,\n",
    "    ):\n",
    "        \"\"\"Initialization.\n",
    "        \n",
    "        Args:\n",
    "            env (gym.Env): openAI Gym environment\n",
    "            memory_size (int): length of memory\n",
    "            batch_size (int): batch size for sampling\n",
    "            target_update (int): period for target model's hard update\n",
    "            epsilon_decay (float): step size to decrease epsilon\n",
    "            lr (float): learning rate\n",
    "            max_epsilon (float): max value of epsilon\n",
    "            min_epsilon (float): min value of epsilon\n",
    "            gamma (float): discount factor\n",
    "            v_min (float): min value of support\n",
    "            v_max (float): max value of support\n",
    "            atom_size (int): the unit number of support\n",
    "        \"\"\"\n",
    "        obs_dim = env.observation_space.shape[0]\n",
    "        action_dim = env.action_space.n\n",
    "        \n",
    "        self.env = env\n",
    "        self.memory = ReplayBuffer(obs_dim, memory_size, batch_size)\n",
    "        self.batch_size = batch_size\n",
    "        self.epsilon = max_epsilon\n",
    "        self.epsilon_decay = epsilon_decay\n",
    "        self.max_epsilon = max_epsilon\n",
    "        self.min_epsilon = min_epsilon\n",
    "        self.target_update = target_update\n",
    "        self.gamma = gamma\n",
    "        \n",
    "        # device: cpu / gpu\n",
    "        self.device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "        print(self.device)\n",
    "        \n",
    "        # Categorical DQN parameters\n",
    "        self.v_min = v_min\n",
    "        self.v_max = v_max\n",
    "        self.atom_size = atom_size\n",
    "        self.support = torch.linspace(\n",
    "            self.v_min, self.v_max, self.atom_size\n",
    "        ).to(self.device)\n",
    "\n",
    "        # networks: dqn, dqn_target\n",
    "        self.dqn = Network(\n",
    "            obs_dim, action_dim, atom_size, self.support\n",
    "        ).to(self.device)\n",
    "        self.dqn_target = Network(\n",
    "            obs_dim, action_dim, atom_size, self.support\n",
    "        ).to(self.device)\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
    "        self.dqn_target.eval()\n",
    "        \n",
    "        # optimizer\n",
    "        self.optimizer = optim.Adam(self.dqn.parameters())\n",
    "\n",
    "        # transition to store in memory\n",
    "        self.transition = list()\n",
    "        \n",
    "        # mode: train / test\n",
    "        self.is_test = False\n",
    "\n",
    "    def select_action(self, state: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Select an action from the input state.\"\"\"\n",
    "        # epsilon greedy policy\n",
    "        if self.epsilon > np.random.random():\n",
    "            selected_action = self.env.action_space.sample()\n",
    "        else:\n",
    "            selected_action = self.dqn(\n",
    "                torch.FloatTensor(state).to(self.device),\n",
    "            ).argmax()\n",
    "            selected_action = selected_action.detach().cpu().numpy()\n",
    "        \n",
    "        if not self.is_test:\n",
    "            self.transition = [state, selected_action]\n",
    "        \n",
    "        return selected_action\n",
    "\n",
    "    def step(self, action: np.ndarray) -> Tuple[np.ndarray, np.float64, bool]:\n",
    "        \"\"\"Take an action and return the response of the env.\"\"\"\n",
    "        next_state, reward, done, _ = self.env.step(action)\n",
    "\n",
    "        if not self.is_test:\n",
    "            self.transition += [reward, next_state, done]\n",
    "            self.memory.store(*self.transition)\n",
    "    \n",
    "        return next_state, reward, done\n",
    "\n",
    "    def update_model(self) -> torch.Tensor:\n",
    "        \"\"\"Update the model by gradient descent.\"\"\"\n",
    "        samples = self.memory.sample_batch()\n",
    "\n",
    "        loss = self._compute_dqn_loss(samples)\n",
    "\n",
    "        self.optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        self.optimizer.step()\n",
    "\n",
    "        return loss.item()\n",
    "        \n",
    "    def train(self, num_frames: int, plotting_interval: int = 200):\n",
    "        \"\"\"Train the agent.\"\"\"\n",
    "        self.is_test = False\n",
    "        \n",
    "        state = self.env.reset()\n",
    "        update_cnt = 0\n",
    "        epsilons = []\n",
    "        losses = []\n",
    "        scores = []\n",
    "        score = 0\n",
    "\n",
    "        for frame_idx in range(1, num_frames + 1):\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "\n",
    "            # if episode ends\n",
    "            if done:\n",
    "                state = self.env.reset()\n",
    "                scores.append(score)\n",
    "                score = 0\n",
    "\n",
    "            # if training is ready\n",
    "            if len(self.memory) >= self.batch_size:\n",
    "                loss = self.update_model()\n",
    "                losses.append(loss)\n",
    "                update_cnt += 1\n",
    "                \n",
    "                # linearly decrease epsilon\n",
    "                self.epsilon = max(\n",
    "                    self.min_epsilon, self.epsilon - (\n",
    "                        self.max_epsilon - self.min_epsilon\n",
    "                    ) * self.epsilon_decay\n",
    "                )\n",
    "                epsilons.append(self.epsilon)\n",
    "                \n",
    "                # if hard update is needed\n",
    "                if update_cnt % self.target_update == 0:\n",
    "                    self._target_hard_update()\n",
    "\n",
    "            # plotting\n",
    "            if frame_idx % plotting_interval == 0:\n",
    "                self._plot(frame_idx, scores, losses, epsilons)\n",
    "                \n",
    "        self.env.close()\n",
    "                \n",
    "    def test(self) -> None:\n",
    "        \"\"\"Test the agent.\"\"\"\n",
    "        self.is_test = True\n",
    "        \n",
    "        state = self.env.reset()\n",
    "        done = False\n",
    "        score = 0\n",
    "        \n",
    "        while not done:\n",
    "            self.env.render()\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "        \n",
    "        print(\"score: \", score)\n",
    "        self.env.close()\n",
    "\n",
    "\n",
    "    def _compute_dqn_loss(self, samples: Dict[str, np.ndarray]) -> torch.Tensor:\n",
    "        \"\"\"Return categorical dqn loss.\"\"\"\n",
    "        device = self.device  # for shortening the following lines\n",
    "        state = torch.FloatTensor(samples[\"obs\"]).to(device)\n",
    "        next_state = torch.FloatTensor(samples[\"next_obs\"]).to(device)\n",
    "        action = torch.LongTensor(samples[\"acts\"]).to(device)\n",
    "        reward = torch.FloatTensor(samples[\"rews\"].reshape(-1, 1)).to(device)\n",
    "        done = torch.FloatTensor(samples[\"done\"].reshape(-1, 1)).to(device)\n",
    "        \n",
    "        # Categorical DQN algorithm\n",
    "        delta_z = float(self.v_max - self.v_min) / (self.atom_size - 1)\n",
    "\n",
    "        with torch.no_grad():\n",
    "            next_action = self.dqn_target(next_state).argmax(1)\n",
    "            next_dist = self.dqn_target.dist(next_state)\n",
    "            next_dist = next_dist[range(self.batch_size), next_action]\n",
    "\n",
    "            t_z = reward + (1 - done) * self.gamma * self.support\n",
    "            t_z = t_z.clamp(min=self.v_min, max=self.v_max)\n",
    "            b = (t_z - self.v_min) / delta_z\n",
    "            l = b.floor().long()\n",
    "            u = b.ceil().long()\n",
    "\n",
    "            offset = (\n",
    "                torch.linspace(\n",
    "                    0, (self.batch_size - 1) * self.atom_size, self.batch_size\n",
    "                ).long()\n",
    "                .unsqueeze(1)\n",
    "                .expand(self.batch_size, self.atom_size)\n",
    "                .to(self.device)\n",
    "            )\n",
    "\n",
    "            proj_dist = torch.zeros(next_dist.size(), device=self.device)\n",
    "            proj_dist.view(-1).index_add_(\n",
    "                0, (l + offset).view(-1), (next_dist * (u.float() - b)).view(-1)\n",
    "            )\n",
    "            proj_dist.view(-1).index_add_(\n",
    "                0, (u + offset).view(-1), (next_dist * (b - l.float())).view(-1)\n",
    "            )\n",
    "\n",
    "        dist = self.dqn.dist(state)\n",
    "        log_p = torch.log(dist[range(self.batch_size), action])\n",
    "\n",
    "        loss = -(proj_dist * log_p).sum(1).mean()\n",
    "\n",
    "        return loss\n",
    "\n",
    "    def _target_hard_update(self):\n",
    "        \"\"\"Hard update: target <- local.\"\"\"\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
    "                \n",
    "    def _plot(\n",
    "        self, \n",
    "        frame_idx: int, \n",
    "        scores: List[float], \n",
    "        losses: List[float], \n",
    "        epsilons: List[float],\n",
    "    ):\n",
    "        \"\"\"Plot the training progresses.\"\"\"\n",
    "        clear_output(True)\n",
    "        plt.figure(figsize=(20, 5))\n",
    "        plt.subplot(131)\n",
    "        plt.title('frame %s. score: %s' % (frame_idx, np.mean(scores[-10:])))\n",
    "        plt.plot(scores)\n",
    "        plt.subplot(132)\n",
    "        plt.title('loss')\n",
    "        plt.plot(losses)\n",
    "        plt.subplot(133)\n",
    "        plt.title('epsilons')\n",
    "        plt.plot(epsilons)\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Environment\n",
    "\n",
    "You can see the [code](https://github.com/openai/gym/blob/master/gym/envs/classic_control/cartpole.py) and [configurations](https://github.com/openai/gym/blob/master/gym/envs/__init__.py#L53) of CartPole-v0 from OpenAI's repository."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# environment\n",
    "env_id = \"CartPole-v0\"\n",
    "env = gym.make(env_id)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set random seed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[777]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seed = 777\n",
    "\n",
    "def seed_torch(seed):\n",
    "    torch.manual_seed(seed)\n",
    "    if torch.backends.cudnn.enabled:\n",
    "        torch.backends.cudnn.benchmark = False\n",
    "        torch.backends.cudnn.deterministic = True\n",
    "\n",
    "np.random.seed(seed)\n",
    "seed_torch(seed)\n",
    "env.seed(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda\n"
     ]
    }
   ],
   "source": [
    "# parameters\n",
    "num_frames = 20000\n",
    "memory_size = 1000\n",
    "batch_size = 32\n",
    "target_update = 200\n",
    "epsilon_decay = 1 / 2000\n",
    "\n",
    "# train\n",
    "agent = DQNAgent(env, memory_size, batch_size, target_update, epsilon_decay)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x360 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "agent.train(num_frames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test\n",
    "\n",
    "Run the trained agent (1 episode)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score:  200.0\n"
     ]
    }
   ],
   "source": [
    "agent.env = gym.wrappers.Monitor(env, \"videos\", force=True)\n",
    "agent.test()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Render"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "videos/openaigym.video.1.13870.video000000.mp4\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "        <video alt=\"test\" controls>\n",
       "        <source src=\"data:video/mp4;base64,AAAAIGZ0eXBpc29tAAACAGlzb21pc28yYXZjMW1wNDEAAAAIZnJlZQAAQOdtZGF0AAACrwYF//+r3EXpvebZSLeWLNgg2SPu73gyNjQgLSBjb3JlIDE1MiByMjg1NCBlOWE1OTAzIC0gSC4yNjQvTVBFRy00IEFWQyBjb2RlYyAtIENvcHlsZWZ0IDIwMDMtMjAxNyAtIGh0dHA6Ly93d3cudmlkZW9sYW4ub3JnL3gyNjQuaHRtbCAtIG9wdGlvbnM6IGNhYmFjPTEgcmVmPTMgZGVibG9jaz0xOjA6MCBhbmFseXNlPTB4MzoweDExMyBtZT1oZXggc3VibWU9NyBwc3k9MSBwc3lfcmQ9MS4wMDowLjAwIG1peGVkX3JlZj0xIG1lX3JhbmdlPTE2IGNocm9tYV9tZT0xIHRyZWxsaXM9MSA4eDhkY3Q9MSBjcW09MCBkZWFkem9uZT0yMSwxMSBmYXN0X3Bza2lwPTEgY2hyb21hX3FwX29mZnNldD0tMiB0aHJlYWRzPTEyIGxvb2thaGVhZF90aHJlYWRzPTIgc2xpY2VkX3RocmVhZHM9MCBucj0wIGRlY2ltYXRlPTEgaW50ZXJsYWNlZD0wIGJsdXJheV9jb21wYXQ9MCBjb25zdHJhaW5lZF9pbnRyYT0wIGJmcmFtZXM9MyBiX3B5cmFtaWQ9MiBiX2FkYXB0PTEgYl9iaWFzPTAgZGlyZWN0PTEgd2VpZ2h0Yj0xIG9wZW5fZ29wPTAgd2VpZ2h0cD0yIGtleWludD0yNTAga2V5aW50X21pbj0yNSBzY2VuZWN1dD00MCBpbnRyYV9yZWZyZXNoPTAgcmNfbG9va2FoZWFkPTQwIHJjPWNyZiBtYnRyZWU9MSBjcmY9MjMuMCBxY29tcD0wLjYwIHFwbWluPTAgcXBtYXg9NjkgcXBzdGVwPTQgaXBfcmF0aW89MS40MCBhcT0xOjEuMDAAgAAAAi5liIQAJ//+9bF8CmrJ84oM6DIu4Zckya62IuJtAMABjzYAAAMAAERqWJ7MgJRqXwAAAwBCQA1AfQZQeYiYqxUCV4g4GKuIAQdgX1DYdTurqwV7H9tTmHVDtK2xHVqZGIKlPlIFu70AA1xkGJUihO0Fe2+CPetRavt6hKEf3FnH+rmeTuRvaHfeCTRZO9/HoNWJHUdnoWQrVZTBtpVAMarkpe39XZdYvVQoLBlg7txyfnhS81gxZhvgJi6wfhd3o+AB2eXLO10XPSKfD8rwoWW9fQ7xE//mCZ6kALwWBokVHFthDQ3dCI6QnOh7hxQ+CN+wJL3b400AP7oAA0kpBo+vyiEVDB1wVfLJY/oHmBtAABCCGHt+RbIs7jXPxzbx+RjVjSfNKfl3ileukKyVvXWKb6sWzGlJEC6AkLrQLSfrQDpgDheNMlOFP4IbSzhDsA6VRMCGdgtZr4HhkB1Cnr5AuERTx9QywAKiaOUOP8HgdsJ31WRt6MUNbta1MdQKwfubwKl5r9pvaHGT35EGpVuA/yL78Z7rq1Rv41L/kLJ9lpAjMtFvz76XdbdMFoYw5v0pGrhiGLg0jdiFtRJcJXqUIo7OdTfZWUpBi10bjs156q3I9ROALplNtyou11UJV4bDzxEoUF+9dOtIAAPINkVmEYwusT+DV5WiXWwdLNLIpb6/bempjxIOjxt2+ftc/qEpllPdXy+5Uvm1oMb0C8T0G2DTEwAAAwAAAwAANmEAAADSQZokbEJ//fEAAAMCnu0QAxVIr6wdAZXE95sl5Npnn3aEmG4RG1e9hcs6/3vWCPefNbPqqYJbwV6MWkQCcvBBLi568ZLpfC95lsamD4+90i+TjycvlIqxA8WAcY/cwd0kuylk+f7iLL6wxy7lbkCj6YC8XEDC1PAjkk8YfQRzkcwQbYrrOiREYHbQt8tr7qzPpEAtZj3KZug6PzDNHWHE/ak4yn+J7biVpOVu9Bh2qxunQwf6iZXZ4I/t8te8HxXAFknbD3QenN9dSuEKIUzleLbpAAAAW0GeQniEfwAAFr4//XpvRhJUDYriAfKNiu5VX0dWvEgAtdIuPw4qzkjvq2AaYK3cOB2uZwby7XgCyLEirR3KAamLf0RH2pal3w7cglr1l46GrjgALYyhCaMsB80AAAA5AZ5hdEf/AAAE/JhCuZjT6z3kfunvj0rwSBrJznbSim3vBxuw4+Vo8C8nwAAAAwAABnOzyEqJVAPmAAAANwGeY2pH/wAAI78dLSoJSCzN2CEdxjsaVj5iGOPLqu3wAACpBvIqwXdOl7wgAAADACLIXMpYD0kAAACGQZpoSahBaJlMCFf//jhAAABk9CIwGc/YIvDqS2HYvhs6ttUefroDmXKUp7tsKR4PbWufvGx4oSCdQMPdGE2WWa1Zd+UWRkdW07N2JUqqVw27azb0gO8JK/sSOjYYpgfPqSDfy4eQ/LXPIKuGcJC6jkjRo4V7ijhzfPxac0Ku5nj2RAmEaTEAAAA2QZ6GRREsI/8AAAgsDLGBpDgK0KUijJQ7ICwvcNPs9N+k71CtsMpWhYXS6pjyVMEChofMsVtxAAAAMgGepXRH/wAADS4Vw2F7aGuzI4J3zNjBDwPQAQFTnSjFYSD1DPbgAbsUrC2y3OD5xZlRAAAAJwGep2pH/wAABR+n1ttZ9HxxrCsjh/6Ipv8T4D8VIC4Syo5IsZpNoAAAAE5BmqxJqEFsmUwIT//98QAAAwKfBWDgUO+wwD6EyY0xPferWKWs8O7Ry8o7qNys1MVTzORJdj17T5S5PyQmOfFdmnv75Y5H8NPx7LiwB0wAAAA0QZ7KRRUsI/8AABa8Q823F3EsS60NPfEOOL5BgA4QGCjM/EDKRacj3gmS70sO4WGKwTiqYQAAACEBnul0R/8AAAMB5bfz3q/Nb+tSYqE6T8qSO4/eSfVTf4AAAAAuAZ7rakf/AAAisjyvqYGgAtWEO+127ht4QIvnbMieu2uGM4d188A3WKM70H/QMAAAAGNBmvBJqEFsmUwIT//98QAAAwD4E4BbrEpxCp8SW8bvp/2AECklxCNtg7d5H0u1sHNIPvOO/FnUHStJPejmQbVZNOVvPego6BO8/sulh8+DywtyEcwP6XmSCapIAi6cX9wCI7EAAAA8QZ8ORRUsI/8AAAhr+1aANwXmuUye7Uv01cDZR+MtLU/lHg+1pSl9WqyqAggDPy7vs53W5whRDt5ybTf5AAAALAGfLXRH/wAADYI5zAC3ADRG5wYNcweUNTZ21eXWGozDJ8GSlE9lSJOkxFBBAAAANwGfL2pH/wAABR0wD21KABaiMzYZMB1UEOHayQCBalrXSh8hSPNSlSStDyTfUFMJeBgH/dW5iVsAAABWQZs0SahBbJlMCE///fEAAAMCnwUdNktDSDe0vW2F/AAUYQKMRk/Cz+5gdJPEWmqA+PvpgXre8PimtizEmghGZjSfCBvP9zd5x2qKcZWS9sAkCbs5hxwAAAA1QZ9SRRUsI/8AABa8REMQAOgOLoY+RqawTlyTJgkHyGjrpQiBR4twwXoAtEp/LqaxBivsmLEAAAAuAZ9xdEf/AAAirDyfeqwAvcAFt1dw9yzdQe60Unrvb4FEybesBcHcFBtGvQuLaAAAACABn3NqR/8AACPHv4v3odHGdI4wKPj2BOhB+YBTURwRtwAAAFNBm3hJqEFsmUwIT//98QAAAwKPmESQwIfMC8zR08cvdmv70A/wlfvktX7TmJtMM1bTo85DHO/gaXzB6vDx+2lE4d2BPn3rnjLcG1mQ3Q5jvxPHYQAAACpBn5ZFFSwj/wAAFixPjLXliOejnARoagVpGQxJSC6Gp2/fQGfFu+EomLAAAAAxAZ+1dEf/AAAFHFJpCTVj84auplVxAO2FD4ACZhqrMESL9fhq+BNHQ/X2szN6aqWm3QAAACoBn7dqR/8AACKyNPvuD7lrgAXUSs9w3TmuZGabV9RIO66qfN42Nph9iLkAAABNQZu8SahBbJlMCE///fEAAAMCnwVg4CI5B7ZWseprtYoABFAatZxIWdD4VFJj7IooV1UtbSlKajqqUVzVANI8z/I4hWXTLFxAH6DZDL8AAAA2QZ/aRRUsI/8AABa1N6pe2mnq9/Fk2oAWtZSHK8tQwhzOW1Mf63vn5/wZfTNLXsHe4fqj/wnBAAAAKAGf+XRH/wAAI6v4W3gVJUUgAcF6oALEZBvtN5UyQTcxxMEbKzu2QcAAAAAuAZ/7akf/AAADALomAcNx7t3AA4L1QAWGBK32m8qycwETopMpAA8pGvnMLii62QAAAEJBm+BJqEFsmUwIT//98QAAAwKfBSoTGgUsgHnu0z2tRF8us5RtTfAqdP/o8w4sD3mXc3JL/Yf4H9bLu4LWhuswHekAAABCQZ4eRRUsI/8AABa94AHCXVAC3AT7yNQnl/ij/BGX02uKf11pCyH14BJA8FL+PhQXaFlZbqdfv++ljUV3/M/gI05UAAAAHgGePXRH/wAAI8MXdWiKCgNjC9rcmtkHhS46mXLTjgAAAB8Bnj9qR/8AACOxzAlvqW+yFUkKpsHN2PHDD3s+DSCbAAAAW0GaJEmoQWyZTAhH//3hAAAEG6Jq7f9A1S5ZkrSX7hUU6mupOA+qg1vrlucxradSFMZkUOgynsr59jZeDBV88aKT5QjfrLihldfyLXKdrOTMA/y9t42Sh5z5/iwAAAAzQZ5CRRUsI/8AABa1DwdxAUAAiqyqOB4kip2Pq9GNWhxpXFCqzST9wV8lPyF/iJ2nNu3BAAAAKQGeYXRH/wAAI6nkr47niP5hfVwARkS0/XF/4Vpoqs/+A4K96q2QpME2AAAALwGeY2pH/wAAIr8fhmLilV1biAHKtLWcQRODa3maS5HyKsC7nNg5uU5hEHbmowKxAAAAPkGaZ0moQWyZTAhP//3xAAADAo8SJjE7TG7NGIx5URSzblhA9JZDyl1U0Na8whFLl+GimjdmsFeDlzLNouCBAAAAIEGehUUVLCP/AAAWLE5swthOI1PzlCyQnTCkWEHDGcFhAAAAFwGepmpH/wAAIr8aznveEvuHJN26npJxAAAATkGaq0moQWyZTAhP//3xAAADAo26uaXc4AmIv7aXPPpC88ksstTgb/OXLfJs6cX5VEty65YQSYyF+1UAH0JAXSudw663bwufPsPr7ecQOAAAACRBnslFFSwj/wAAFixObMLpzyhC5zwGGWgh4Ue7/DOR8zrOTiwAAAAZAZ7odEf/AAADAdqKHmSx9rvdIGlxT1tXKwAAADEBnupqR/8AACKehQdeBABxudqdB/SQgxa1ZHkVH4wtiarjhGCLpn95oiT4QppcqK8XAAAAaEGa70moQWyZTAhP//3xAAADAo0FsOAQq0H2IK7OdbiMnR6fSh0tcXBvksxVpZf/Ur3X3NTRmE7gu+QaSrlhZ9uot6Z5B6Snzzi8W5/xfX4gv3xp5n+XjmC05UmTk9IG0uSRQqzhWJBYAAAAPEGfDUUVLCP/AAAWFS9ALYgAjIb3l6NM5lSVGtgBb4e4tw/b7VX6o9jE1lIVcka5Mv13Yh+vZGWMeM/bMQAAACsBnyx0R/8AACKYzk2Fi6xIp5ypNEgBxu66SDESKfxAAnEUnvXilk8/zHJBAAAAKAGfLmpH/wAAIrIvE/2ACQd76N9YeN8NXaZkbCwodtbl+EOm0/NEg4EAAABEQZszSahBbJlMCE///fEAAAMCje35hQ15SBbMn+NcJTguzksLXgElDLCfo6+gAIO7V5ofj6LRNCZf0gBo/CSE4Qx26FMAAAA0QZ9RRRUsI/8AABYjLI/5HM8wb2G8SZKfAOs3A/6ABOjWoW2+pVh2CoZHElJQ6qSLTEPKMAAAACkBn3B0R/8AACLDQLExLUU6sPBpABaf2+j6L+qA8+N4Gh6bUmqmcbVQcQAAACABn3JqR/8AACK/Gs58F3E15KIQ1GGtvx+C4wUHrST/UgAAAGlBm3dJqEFsmUwIT//98QAAAwKN7fmGbVDGCG+/9Y3T98IBCnrYlWH7RI9TR0Amk0zMEPqIScsNrMprYIH13kpxKYVFQOpQkqv8kPukbQWjDhtrCEOGSsFadXzj2+jMH60JAvADZNevN6AAAAAiQZ+VRRUsI/8AABYsTmzC6bGkhZ7y86XqJKcx4fsg53MFgQAAACwBn7R0R/8AAAMB5Yfa5sZxaAHgmvuAAD9zP3l6tHsJaebFnZOYC8KWe3iTegAAABMBn7ZqR/8AACK/Gs573gm6KCRhAAAATEGbu0moQWyZTAhX//44QAABBfpWBFlQnmN8vpo0ZREr+MiSssxZGADtBQ9NjrtI6T4QaW+6RntnnrfDFENCisqaxocKfeFvutMip7EAAAArQZ/ZRRUsI/8AABYjLI/5HErtgyq6YskbzGbMLwsDJAvmwaXuTp+U2Dn3oAAAABoBn/h0R/8AACLDQBBhsUgL+mxuLpgGF50QsQAAACIBn/pqR/8AACK/Gs573gm2Yqd4+P3VU/S+RagFulE1+gOAAAAAL0Gb/UmoQWyZTBRMJ//98QAAAwAB3PM5Q4S01FLt4Xq0Lee6FQCy9pOkDa3BBhFRAAAAHwGeHGpH/wAAAwAZv5fNphJUeowRsz9r/DkeV5zjW9EAAABKQZoBSeEKUmUwIT/98QAAAwKOrMCnelBIOlygAG1Cln6q4WT493cdW0z/DVxqTm/0bGk4/HIIQfWuPjcwz1I+d96Z1oU8d/ZnyS8AAAAmQZ4/RTRMI/8AABYrlDcjCd0EItNmlf/QNFAhyEwJDf5ERAhmuCAAAAAwAZ5edEf/AAAisK5kwA3V8FvsyaAJrk3jG92XDYy4kTaqv3/y6iRuiHA8OuY7lVcrAAAAMAGeQGpH/wAAIrHMEEYoOgCC5v5K/XWWub0f+o8q06qz+utquaCfS7rQ0CIzrnzb0AAAAG1BmkVJqEFomUwIR//94QAAAwP1YQo35zobFOBJE2gJxQNYAbciMsKdVIo1EpnDrx0n8CqAUqyDjRcqeLsg87lxoyoUAQe8UErmn0MPboeyyV1s/Y8vrvI1Ds3TVWGcWykDPIwVlDjENYXbze3xAAAAMEGeY0URLCP/AAAVnFC29NImXhBGs+vUe2CN5uR1tCDmklwzMxa0+Zptt/b96LCXpgAAABwBnoJ0R/8AAAT4UmmwhK0BkHZwopqnMhhM9VJtAAAALgGehGpH/wAAIrHMCW/bTHDUpqqJLwozoFob4ACYfg9bvmA9BxAjek+PduxsAhcAAAA/QZqISahBbJlMCE///fEAAAMCje33/isSnWcBI8elkR0RjzpoPaPh/VSkrCOsxOeAUWYGu/m/dhoolYRfagRNAAAANkGepkUVLCP/AAAVnFC29NRMQQBElpM2Tmcpja/PxBgSwJbbxzzRkpdKafKWqjCLe/6O/NXc+QAAAC0BnsdqR/8AACKxzAlv20xsQSFeg4mkluAC1EZVB79ilQh3+DFejaaLJfm8f2gAAABNQZrMSahBbJlMCE///fEAAAMCjQWLoBCrPzbZDgQbHgDLkMHW8VNZU5zg5AmZawqQKm1EaRYVj92Za1+/sbWhGtc3Q3IMz3uJaeiEYrAAAAA/QZ7qRRUsI/8AABYrlD5bBQABOr52DLV+BLAsvf3YuI9R6lp1+Ix6Ww8jqnIA535vxYfta7rsagmnIQ/jaSufAAAAHAGfCXRH/wAAIrf1zo5nWwk141k11MOt8KwacbQAAAAvAZ8Lakf/AAAivxoPhR1ZwmN4RfGStY5QC/KOsoAICqHGA22C/bQtwh9AZC+YiIwAAABbQZsQSahBbJlMCE///fEAAAMCjPfi0/4cl6AEqGbkL2Pt9BXdUxWnnP/rGZz2tRdM5lT26NHKo3RSlfweyRM/QCEy7A837beJ0CMYqK6p9DQfJyT70ctEktq/iQAAAENBny5FFSwj/wAAFiMrtQW5HK9QAAajRraOfhYkCNY4lHg5L4b64vqK0ijw9y687cLfB3Wa5OumyE/RKlNLExbUpMqBAAAALAGfTXRH/wAAIqv4W3gP/EZB2cA7It56AAtGfNu89G99LqRSkUfrtWdrCDehAAAAHAGfT2pH/wAAIrHL/HtV1nYORily0GimDNdUAr4AAABvQZtUSahBbJlMCE///fEAAAMCjPfYbkv5nkCADg4TMWF1Py8OtqjKCd7xj+eF8Ff2GF8KtfcF+anbdNBAvruOHMeFmAUXsiQmP7rq9Ja73O0T9dK+oce5zEW5g3DxB6F7/6pBYr9fuiapZFRXEAEsAAAAS0GfckUVLCP/AAAWIyu1As28IDJv5MvQAO6D741RyHtmxkOV7bqeMKw9IwRX6LFEJWe3he+yY0K9e/PBX2oJ7SG/Aovo6UJMRQb58QAAADoBn5F0R/8AACKlipgCtmebQXtUh/cJZJw4OsHYkfmyIp71KbBGhf9zsFKuQj1jCV92FQb0cr+owvCAAAAAKwGfk2pH/wAAIr8EJxLK/nPnKfGJnvGasACWqeLGwRby7wg9e1rPKO5goIAAAACBQZuYSahBbJlMCE///fEAAAMCkcn1mSj2wDV8r9SgCSbavMe8g4QFeVcIPYZ/10Ckl2p7S35EsVpTu3m6JnPN/qprsdolZavm6J/utvsNYCFBkdCtGuUakPKjfk6Z0ISo3WQDd3H+BDjzRCGZwXObgSoOTHtV++4VY1sN+ZSZcsfRAAAAR0GftkUVLCP/AAAWJQ7ybykqZFN+Ek8tIy26IAWtKf6bgwp4ZoI8Dlj4+scofCYc6bB4LrwXQYqu32tbg3kBD1OgP6+Fzm+fAAAAJQGf1XRH/wAAIsMXXy7y8mkTi2/WH09ZSdzWiwWd7ysrjA0d8+EAAAA6AZ/Xakf/AAAhxzLHDOc28h1ADpAIUivf0OOQe4G5MxJjDLQO6zHejGcuOO9I79eYFDqPe0FC2Y5OsQAAAF9Bm9xJqEFsmUwIT//98QAAAwJ69+bDZ9BtxC+pMeSVdtdLjm7Zi2w2hreFWwBcrhbpqHoG9doQhC/Hcl2r7qGjrBSRG6H6+l/fmOoDHfdINbEt3ZMqCjlbwHApoiVcwAAAADhBn/pFFSwj/wAAFZMsgzS0ldfx7H9hpI42cQHdjITuW19gT/BRd+Qj0yJ/CBWWnwWf7tmjvNqAgQAAAEIBnhl0R/8AACHDOpwkKCwCACR1vpSQQFwnepj48Ugh94Vp+KHqyHUJd9qPLSriNQbbJOi154LLf2KkodOL2PJMCPgAAABHAZ4bakf/AAAhsiosytyqT+IAC0ZcA7wHbNgkBoG/rncc2kV7WeGMoR1+ovo+pF2pHLT/S/4QdViF9fM7ABujFEpxWam3uzEAAABgQZoASahBbJlMCEf//eEAAAMD3zig/ANSkCHyTLC4igqACFfjomShGaPrVvwcEwiLhg/DorA3hOQ5ZMOy1Db2usDGCfS+QACYYNzs8aJLz4l3eMG/DEyjXWQxAekPqnHhAAAARkGePkUVLCP/AAAVm5SNhgMYHoAY99n/AwpRusuUxqDKQhnU4AUvPpJd5G1ZuL+Q0IceKuoRJY0y+ESzwRDZSclBe+4yiSAAAAAyAZ5ddEf/AAAht8dnRBeNQ+Qw1Ic5M20ZjLrd4IcoaY/UMADYbMnQJibbn865g6N0XVAAAAAyAZ5fakf/AAAhrjI/gvRwBe3aD/4u6f0ZsKSOWycQT3DgUrcf19HwUZeBCZZVDHkS/wkAAABzQZpESahBbJlMCEf//eEAAAMD3zcV/AUEa7HgxEkm+0hhgue73XakiHlMcPBEs2LP64UOkYz9zBHsc1j0fMDYjAwjfbAWf+4PIVJvLzCycaF/NGAd8U0hIiT5OKhsP9EkqeH7Ui8GtO3YxNcTvgOFK/JQCwAAAEtBnmJFFSwj/wAAFZuUVLGKyd9ZybXiTjLlx4yT3jsWb/nM9JiyVRQAiuwaX7xKWn+jqsh9XYASQzO1F/IYI3+sdf80FNAXPyG3xYEAAAAvAZ6BdEf/AAAhPcs6PaxFarfo5eV97fxsJn3UWLxUe2LIAEzCyqEA3iKCOG3nCk4AAABBAZ6Dakf/AAAhvZWtu0+HZXa6j0f3i3qymQZAQ70e4onCV64pks+PZ3HG78VgYzC3kkqmRRiKmh4P1/8aw5bOBC0AAABxQZqISahBbJlMCEf//eEAAAMD3zh9Tyv1uey2b7Qup/w9gxkIbpEGfct3oTgAr3Ym0Cq8Rp+jfVuNpJ6hY4Aj3W6JEbkYDYS0u/zFz8aYQHMcZ3CJwi5IfHoP22paFo/K8a9nDq3L1ssCPwD+siFgGOEAAABFQZ6mRRUsI/8AABWgMX3iP7tl0bKvdUlOOZ5zJ5gqfSXmM2dfn4xsgF0/jPglDwN9+rPYiioc+TSJABqGVrzAdITeYPPhAAAAQQGexXRH/wAAIanPZznoWDwyxAC2utrhimc73rCi24376C+lVw/Si2tQv1MnYad9hGSk53HeeLGgMqIl35H6fM45AAAANwGex2pH/wAAIb2VrbtPheJ2unfXumdvolTK3gZQDbxwHeRBQBqjAgBLwQxnuwkcMe2F9OgHE9sAAABqQZrKSahBbJlMFEwn//3xAAADAnu3FOi30XY9ZOIsomdZosWbjuFPYia0HA+UUeBSmKx7gxTiKwoJBxDv/LlIU6jAfxYWaTva0IooU3ozg2/W//37HWlUthXn+8bT9YZZ474dTxYEC1V5gAAAAEEBnulqR/8AACGmETAES6y+OhfEUGVexUpBKV7Lwv7Qx/N+gq8FsC7unpAicmzNfLFMNENo3MgjC1oSja8QPtLRgQAAAFNBmu5J4QpSZTAhH/3hAAADA+W/6mZYbpd9zFTMerUcvdO8bvWhpSaotPE3ok6eQcA26AYGxe6stxxc33i7dKUOhZZdzfUu0AH3GjuGXpMkc8rBGAAAADxBnwxFNEwj/wAAFZKe3jcbRyFOxM2OubSjyD5u0KZ1M2gBrxyzU0fACasHAOEEs1nx/hopJc0mEo7RChgAAAAyAZ8rdEf/AAAhqcyodl0CkmWZf8z2OFkUkhOlfPYrpW/UKryj6F/UspfQBf9JZ3Z45G0AAAAxAZ8takf/AAAhscENkXFmuLPegw/MPhAcTjsxAy0ERRpc3TGIL4kquVnooxNz8kIjYQAAAINBmzJJqEFomUwIR//94QAAAwPJQMShADb7ze3KliFys2VOOb/WAY3NjJ0otgIkiEB4XAyXWNPLxvGD2HP+XZVn6tEJ+QLa32Oc6ex92xZ4FUgztW4pnLJksf/d+bxaGxORZ5sjWkI6QIwQ/DlAajtRqxjVg2lJNsx22ikXdnBko06dqQAAADpBn1BFESwj/wAAFQtfgv3H0OC/mBb3Jnl+krJzLh1QxL5nx0Dd1qWJXG7mUfnLhBDHubVvAomtvIVIAAAAKAGfb3RH/wAAIMC5obxzhzTHVZEqJ2o0XPjhdmaPatJu9SqUrMpJcA8AAAArAZ9xakf/AAAgvXRbImy8fbgVKJ8Ip6CTqzLP6g8pdYY7BHcXCEUnfF6rjwAAAIdBm3ZJqEFsmUwIR//94QAAAwPJQF1/ANSjQUpgzKTbFo0D8nw0GiBrJWvCF5bqj1ykC98KWT1Sd6juJMeIGxNpJYMk0G/cvPVMYLqEl1WC2/Juioee3brwpxZyGni2hhe/eXTDhrTCxxrV5ygO9zrX4UZ+IZYK31CDUj7RVwtLCRgI3ADh3e4AAABXQZ+URRUsI/8AABULX260ZseSlSzlvC7XUFj+YxVAAJParr76ha98pDzXPdwMLYtmfkQ+shLYAIf/B1CjoejmkuqG7O0PDFmi9fR3XaTRjsEzRpdn5nHAAAAAMAGfs3RH/wAAIMC437+uF98166CsJSqoxqTUMge8jjEjHR6wdGi9fc8toqxzE69BUwAAAEABn7VqR/8AACCZq08FOHrNuXjsSWIh2Kh/LIZ8UBojrrEFcfbFEaTQNYo7s8/BKgAft0O0+jxYwbpymzyrptoYAAAAnEGbuEmoQWyZTBRMJ//98QAAAwJpuFsJjsPgDbfwBWNDPAUoiLCsk3jdT5nBFTnyYSmnJ7X3hECYI71uNPOpJ9CQQwW5jMr5rSPmVo+nB7mIYa/CeeWvzxqrZocUg735gkUSHKl98CsQale7KotyvVbx2FuLsK6x8t0t6bujDXdUmkRiiwU61jIHGEUwjYwdCwmDEYdRKkVcleXLgQAAADgBn9dqR/8AACCtgtf0SFVPK5/E7wo19Ann1xMZLaBJTOfqRmDYqZuH2FUgjguNeV345lcar8LKMQAAAJlBm9xJ4QpSZTAhH/3hAAADA8+/641F6WpXDQCEH3+HOWJxY/k+K/8HW21RCX5091AFFbqoIt5MYT2FzORmKXe+JQWT1ngHv5pgfwyg+4DjvCaFESkdku7nUhLnkRbtwwYaSwf48ZO/39V3EJ+d7vbojFnRq216pvD89dM6TiMv+ud39PlNZE8bcWl8yMZjKasG69HKC7hOtaQAAABYQZ/6RTRMI/8AABUFDnqkmUU4NzREUqnLsPhts3mPYAAcdUhkeBhSbjaWh0/4wUwfFeb7LlhaZav3CH86TJdQEReAGQeN4GDt5gXy4GflRoXi6Mj3KmMumQAAAEUBnhl0R/8AACDAChe39hSb4vaDjDqT3ogMgJ0V2UOWD9Fz7EWGcvJZ9fb3aSJlAucna6ldAOSE1Mq8jYAHm+0YZGhpsz4AAAA9AZ4bakf/AAAfsVGFDQgF7Xe7kgwxsOt2bi38BS07ksy+PnQSzrpnzKkIrabQMcJ1/4Faa1DUHwKpjeEHTQAAAIRBmgBJqEFomUwIT//98QAAAwJZvsdUX1yjfWAC03uw4KUkEL8rp9LA67v+I2cUi2sNNuBDOz9Zz3xLQH2TCOvg+7P/FlOd8JEHlSciKqJvOMKKcXVwtoH60Or7JawCe0O1y+CTTyY3+NIN93D5kLVXHOXPdGEFcRdGFcp2kcF5UxN87G0AAABhQZ4+RREsI/8AABQtz+XDv7jqrn927dPNeR8Pn+C3hqLFTcwfoY6Stcwjsg9M10xQz1TahM5YPHtcf7e/rKnlIPrqAmRa45tjmfFtAm1opTwIcpLUAmFcXacVJFPY/26v0wAAAD0Bnl10R/8AAB9k4rwK+OpDISObqoaWF+LIYSUUw5E8v9YdYU7rhKsUTES+WrAWhKh7SUuisojU+6+K/iswAAAASQGeX2pH/wAAH6qaFDtAfmLEKJZl3xjqbWdHrxYAmgS2IRSo8wsQqhqKjEAW5CXMQL/rJVtFdyhqZwATEJ/Uy86PXrpcRYLVKzEAAACnQZpESahBbJlMCE///fEAAAMCXdE2KTITgEiVAHLeMYq8rdyecej/nq13cqOr527Me+fN6TNoul6HM3RVVJhLKF30jmdG3/FlmryBBlcNSjr3HqTNnVCO/mrGFBil6b9X61waooBK8pSPZxzXx3VLTDzBJcS2oAxvAOSdzUDLjd2q0W37NvBRvgx6RM9G+Ico8+8xFDrxXFTrr1eZc4mNYDqrXKB0viAAAABcQZ5iRRUsI/8AABR7NpQMGaAEWLvf+QKa6Sp/6GT1l4QvRMpZ8ao4kh7+AjE43oU8sAJIWq0UJEkZYjPAWNCiVLwxLeyNoqpCNOPx0utxJw0OC/FjpwirpfsmxcEAAAA9AZ6BdEf/AAAftavW7i+l/FyvPGG4bCi9RuzFxp4AJSLl0b587QSIS7veFNtiGaJm84KSKUgzI1CLcqHFmAAAAEkBnoNqR/8AAB+8A4mqiDCrfaApNSgG0WQCRfEbEGItaMZ+jJclZJTxxQ/egrcdd/4xV5sW3eAiIPNvwE/Idw8wAndsWvuhJ08pAAAAhUGaiEmoQWyZTAhH//3hAAADA55ItI/tafBACklxvgBkYpfFgAjn45tSdok0AtIdACFmhRqmFu9fNJccnr+H5403zggGaqkHt2pUbC1ucX7Fjp6jZnynxvth9Rk9aRbQxh7ss5OSc9wTs7xPWW5ODz95VKwk9n8JaTM2oRqeHBVaF9iMaa0AAABtQZ6mRRUsI/8AABOd6sj+AF9gZ9oCnzLNXSWl/3sLreldM7YmFNohbUyOJEs7cllY3gIMn6dLbZ9pZzX4acZBoSjnQ5nlf6hi0tjr3Z6UsTsP7eQTHiU+d7Ml7AU/9DAdJGhMvg75GWFIA2LmLQAAAEYBnsV0R/8AAB71GBEe2jp2UWl9WGFadqvLAUU9efrsO4ZEFYz7w3N8By9OWNohG4HxPtNABOn+Adv9ltvvbOHgFdpRArbNAAAATQGex2pH/wAAHwE7H7QNvSj1p41agFUv0kdATnKUWBzqTpZprqlkY+koZ9dFZM+BjdVRzXcPCnriUDvVWFTEAJja23aeTgP3Mm1y+gzIAAAAqUGaykmoQWyZTBRMI//94QAAAwOjv+pmqEkgCeyhpP3iYs+266KNwK1uC3uHy8ip32rAlzCuAEZ6G01/SoveIGUJBJYZOEQitFlPhm8C0kAAvSVBv/bVtDiKNu3dnEyCYYHs6WbM9cO/1jukgnS4dc3PJ3xWalWPVtAsMgnPZjYnw2vlUKTo+8hZiS/XmMT9WeFo1UJiESUlZYAseFcybh2c3oppdfmsX5QAAABQAZ7pakf/AAAfCOt2GnQSCEpnCMeoG+asi5gNEK31A/zrcA5qfA1gtq16b9QHsoW8Hvf8rpoMmeGJI9FLEHKYa88AWLE+ij1a1wNcH7fEUkEAAADCQZruSeEKUmUwIR/94QAAAwOKJGV0wuUpQBtTFmSHkL/mUf7rn7/4clgd36cl7UGAUV56KQFfXeLQuBCrvt+dh7H8+zt4bu4IoiQ2MuSyACxbvdVSLIK+XXLq+l5FPrZiyKKGLCXBo5cE5D6gDMhThQjtsk4eB4UFsNyLLdWjdjSgujAYjCiKSlRjULT7Dv+X+lelnDdd7ScgrdJ7/7udpWOZBKBHzLevZ9gB/BlWigwufMZ3WGuprAZ1CDZs+BynRaYAAABxQZ8MRTRMI/8AABNJq+VJ0K0FQR/LOWUSX1yKvv5rGN9nnGfcveqUKyycBc1ADfcpkd76Gnu0bzWqQMApsxm3kMryXTBwDgpRRbs9z3F6I+IzUMfmg7ctyMQikVPiEC2wDMFohDx+Kd0wnXjdtzcHIpgAAABRAZ8rdEf/AAAeaC9UwA3Mj1sdBu+RltGEXtF0osA+TZloc4OwXpZuvrhwF4Uy9CggAIWBpgZAG5hwt1B4b+TQik8bu4MHA8xt9AAOpySxfuZVAAAATgGfLWpH/wAAHgTJrqbZCckiIy5jhFUcGeQLbCfL/Oamg9iDwuET9QMjObTwq5+8AgtVwVvQoAP5e9kVYFLy1QcxpjtML2CxMBPrKAngYQAAAGlBmzBJqEFomUwU8f/8hAAADcy/K4gC1e/Q/FWgD5b3QIQPjB7W8jEShl120CLtVwr2xbcZ0Bb5pVL2ir/rpCXAU22v8wWls2I5BtNtqapSjqvBp4TtsrSV+jHIcjKttJbVN4MKIRI9tSEAAABNAZ9Pakf/AAAeUUyIFsEKlxN8kj4m90RzBYZAogf9+zqO7tm+mzMYoXu2nVZ3VmhwR99Oax9KXlUAJpc2pGhzFdIUwrdJo5rr8YbqrugAAACtQZtRSeEKUmUwIT/98QAAAwI5xF451NrrwA6R01LWESDcwJmsRH6cCpx99oP3WydEeereCebpgFNhUQVbPNmTLc+oLbmrOBL7oqNV7IFqzBFD0S+DKFjZc+m7nVFnKVlFqn9y/IWkGe3hv+bn9f+6m8Soo236QJcY0BsQvpC3Ecc5pxT8Gl70AR5Lpe5txbUmT09lCY4OvPHEFNCJfqCUkiFv6bTmKGXSnzjOi8AAAADSQZt1SeEOiZTAhH/94QAAAwONv77tx8VHlWgIC3UIyrhyql8ZCCJm/u4N8gov1NX0R9+DIp7KAOkzF8NG1TxF6Qk1xeAwRH4oQfQ2PxuI+lReFfVNvu3bJFmK1gATyIn/fXE3Mz8IGTvp+XQcgxxsrc9cqlQFfheMuyKnre7IXpcw+8kb1+/9M9u0vd+PnAav+FSn+D1k4hSsSPafi90h1cUQzbPd9pAkm8/qlLLI3V6+LkGm27VtPzRvOjU2DIfSD5oc1FkCT8HALt06N4CuobOBAAAAX0Gfk0URPCP/AAATV+pw3dLnoatxDpAEBHQ8ynfSW7x3WT/ZzNxlNlhCJJF/OCR9wXRZdQ0FpsYLRJBsufjE4+VGrRt9BMLnx1MjuktnXUmDO+bBnbHAN1cEpByDzOmzAAAAQgGfsnRH/wAAHlgz83NEwrHSxvnkU0rNE6CjOKKoPR97KbEfaLSUrITNMmjJaCcD5jISfZMqfFDH7HgqeSVGJiPhiwAAAFUBn7RqR/8AAB22Y2xMGs7/RPF1eLT61YI51tbV+0zQovrOnI3GN+MV8wYVMjYWwWbhokOgAiDoU/LFXXoqa7v1fzCSmYBtQKi2heQq7Mb3zvaauYl3AAAAxkGbuUmoQWiZTAhP//3xAAADAi3RKV8A3rdoAvu2yxTs4I/j5U8AT0p8vKwjJZKYnoLnu3XnDKpf+gyqSMcIJxaDMe2QUu4Lyfz3fVIP+5x5g/Pp+yU5Aa/DNh/ExIcarOGJXK8z7BemhwxjXeJfOxxbeCBGQZo6l6C1V45jmVDm1FkhFHqrds//DY8Jp7c+vlp6tNytCOSOjypSxXnVbydT0duJzPhoqnHVm5eiSV/gnruwVgX/hjFVzPz+UQmvLyyQWabWXgAAAFlBn9dFESwj/wAAEt09wQIvww2PfjRtHM5gz3O3ac6snsUs2Yh72nRbY579yqOeH5YVElbQTevUnWdhJjf+wDJG6E1ZcPPJh6svO0kjpePXKyimxwsGExKlJQAAAF4Bn/Z0R/8AAB23Q9H1lghMUA+PyiYgL6Usj0d5gk+wx+RmZGd+uE5S2cNMPyHIuz8VbM8I/CMAE0b1pu7WRKp4Ow8bq6vpy36lL8BhcB9C1eUKBxrH5vMnUylqO8Q9AAAAWAGf+GpH/wAAHagF9fFFR9mAF5qDcroL+E5HTDdlLf6+8xHUwM6ej24WId+QJ70PAuXT/vVEUairBNH4yIjNTxkobMNgBLneSVWhtt8cIVdvfUE+YhYzh3QAAACOQZv9SahBbJlMCE///fEAAAMCGoqDHZoWzA9yiHqly8supADd2vUuyJWELJx5anj7/jsnoLClzuzE5Pwb7QqnnhlKW7OhQ5JlZ7P4D/1RNaOu49W7hVJ7hqdgM9u5gnSZMMg/HtpQemd8Zirrve01mUdu21kF5AzGJkMfe1XQsdQWSSebWTDnuXH0Tfy92QAAAGBBnhtFFSwj/wAAEkmtCVJWyuqHIy2OAgki/W5Ompl5V2OQzIlC31bZm+7WZETsPZ5vcC1S7usUatpefjlk04B69K/NAB+WJlgIVyKogYD5e5YePLHNDtGxg1Mch8WA9IAAAABHAZ46dEf/AAAdCC0M/mt2fiQm8IHZZijQ0hiTQTkf3+vCOymTOUb+9CyKiIMAPtVmfRbBYvpWQiSR9e90oyUiC1r8YuIARcEAAABIAZ48akf/AAAc+O198AFLH9PLxTTmyscg2/9jHsgENKlUM0N1q3wzJ0cN2YXWJVFnTLSxbRs2ABO3WdNSSYGZs8wmEgvAKsWBAAAAd0GaIUmoQWyZTAhH//3hAAADA2O/6mj6FVAJr0l2PShDn7tgVv2cO+iwN+A+v9KSuNhEs15kA2yyg3ixsv9Sh1g76nL+AxdVoP7oW6YvSRwCqmKFIdbklb2ijc6cLrTRFb15hIUtIRiE85iwMoyfwZQ7+92KS3yIAAAAXUGeX0UVLCP/AAASV/6G4SDSHZ+it711oAJYZ/gnrZiaMtHPH5hk3qh+JyQJr56Xam2oXfYg4xshvMeqs40kIa6k9gXQAFs8Xq3AFwf11yQMVtotHNQQhtjD7bBwQAAAAEoBnn50R/8AAB0HYBS55YOT9shHMztsUsyYOW761Zfy/QnAfP7iHgk+2vofTx79kz4MNrznpRNIuABMmf/q3vGXV3+ettKiPSgD1wAAAEABnmBqR/8AABxI7YruOolGeroqG/IQThJL/hTTPksNL9nh/Yfq7yRtjQ/HHz4lhsALqJhWhWWXmukMo8g4zKJgAAAAaUGaZEmoQWyZTAhH//3hAAADA0ooPaTKSAUk2ZrCYIXhF+Iie6rDGI9CUhUpcTYd74HZK8szWfDVO68if+1s4YcCU1k0WNsvN+HCP/FEAqGOyzSHVYlfJdwstkpzAANTrXIS/3NN+bLlrwAAAFBBnoJFFSwj/wAAEZyNjBsApx2CD1+Fu4v9h34+LLmqMZtD/JsuXLkykvCIL0SABsViUgGPKpS/PtiVo7bpMejCUlhJlM+5OwgFg4fI64b40AAAAEQBnqNqR/8AABxI7Ta+6MxkbyL5oAERKURPtQSE0VrpQDOYkBsxHb92LV1viAEx6FBF9XxysdEwxLoLDyJqG6uMumJ3oQAAAHFBmqhJqEFsmUwIT//98QAAAwIN0TWX/M4QAdIB/q9gvbo9s9LBplAaaSWJHXpGspYX5FPmyOu+TcJhRXDGBq2ebeLQNCnDWQyTvillarzyyzHvrFd8tWz2kBrbPoqSRt8RHhjPUnkyMgJEVkCqgex8gQAAAFFBnsZFFSwj/wAAEdfxEhBcxnve0CIrblhw5jrIj7vAHxcYWSLCCjoAFyP9GZAgzwSKolhwGaIzemPhKWEkCYSV1IOg3sj3fTJaDkfqh/miF3EAAAA2AZ7ldEf/AAAcWCz/L6K/TteuMNf5gtguuEU4Xr3OAZnz0vTvgq1QjP+bQWkFY0URPtUCnR9xAAAARQGe52pH/wAAG5xf2jkPcy2JaElYmNDqC81+WWCDOghEc2CKndwaIDuMMNfocK1kUAB712Lrc9b9FLexA7v83FfFmrRRsAAAAHhBmuxJqEFsmUwIT//98QAAAwH7QckBvJZCt05RZdrGDqE6DmhIsBc+8mUOAABERqke8FpzP6hf4Ri+IbV3xt1Q4hoz//gQpYxcFr0l/FWK33gmU2MelTfdQup3vNFsfGqT/sr1Ac3TlU5fdf14xp+Yw3PYVHVw04AAAABJQZ8KRRUsI/8AABFVxviFpqgCtQdsBktMqKAQ4rXfHZKOZ++EMlOb/Z5gMMEdBXuzFSn5+Dwv4KkziMpUX8AvXxzFoL8qtz1LgQAAADABnyl0R/8AABupbbylfllVuUUDM+v9HxgafDjsZhdUzAp0Ot4Qqo5rGZs7wcqYC+QAAAAvAZ8rakf/AAAbp/tvWG5WO9lskBt9Gl/ez8nsNzqVaMQLr61k2dEDB3eLNYyAZAgAAABdQZswSahBbJlMCE///fEAAAMB/d/1l+pCPj+pW5ILUIBdAMfGiSEYajClMYkdZXiVaRgA6Fx1lp8MSSZxABqQdrW2xm1VspbXmv25RVO220T2uZ7FkUWXd7rnWP3xAAAAT0GfTkUVLCP/AAARV/ESW6a02vqp8QDFSLC67tDjFySqCUTkD1lBJQBpcgeifVMPICtFSYOnJpaa1ze7E0Y+MEKmR589vRezoTS87D/w0uEAAABBAZ9tdEf/AAAbmjaRFbAwM3zjWCVI6ZiHJ9SGlD5UZQrWn7e6V4w8PGAR2DXWXJyAB/CnMBhDY2ziexAh3VXFZ8EAAAA9AZ9vakf/AAAa/GBNtA62tR77ZKY3DsaMiOsI6PEbYrernGJavrv1iIAEPpP/g3W2cm/sxg9SNu4zC3B/fAAAAFhBm3RJqEFsmUwIT//98QAAAwHvtipoznwD4nTxCUvB3+DZoqDd4Z/akJi3yEufh142l+N/o6HUA+S0MeBvZpF8kMRJXrP6RK/bh5IU6klOh+89ru7yNPe2AAAAUEGfkkUVLCP/AAAQ3SVMiBbhSlWvR3KehnGn14SpYYAe+N/R5QqA5N0qkAEQXdtQb576zP2rAWfh9K+PqpK6sIJYbBIwMRKIqTr1F14SlfuhAAAANAGfsXRH/wAAGvo2zrIFtUGEo3tPVLrSiPF74YmwzwWkLYTMggq+y1coWubD71cEDqxuDPEAAAA6AZ+zakf/AAAa/QoOHGBKYZ0NncJw10L7+OopDrNKO98/ULfI0OmgMB+aocX1r0feVMmvcl2jQ8ZMwAAAAFZBm7hJqEFsmUwIR//94QAAAwMnv+poIBun8PQTFzvnTgdCZy0J4AAiI2g+c4G2o1LBDWffR024CygLtdwaZnpIJsbnwdvWZeysP+BXYA6zJvhEc5EcwQAAAEJBn9ZFFSwj/wAAENW+XtZbG4UWJ39Xj7D6jU1y0elpkduKR1LecdrWAzAzb0x/kS1xhqguNDMJPz76bEVLUiRZUjwAAABAAZ/1dEf/AAAbCW28pYlYd0WYgACkb4F23yYHNT6NkIB69yA61yMv8RJS85X34YepyK4pACX4DY7S7UCyz/9G/QAAADkBn/dqR/8AABr/Y7CZRuabMHn/G0ZCLWdf4FcRboJ3Sfk1n6CH/MAIOz3Bqp4HPLkO8J1HkNyN7KEAAABYQZv8SahBbJlMCEf//eEAAAMDDicpz2lAopgvQEfhGEcsiUyR8Vo1M1JjUoIyqj6EFAhGR4cEf9Vh3Pla8mVWa4cUaq17ym+xSAAVXbth5LHP301B6F0eyAAAAEpBnhpFFSwj/wAAEFW+WvbPGoZZ8NrdyuNZHamqwLBeVdp0+mgfuKRkNG+j3s0ABtGaWBS8na3JSwanuzGOW6wDalPyQrKvZkdaXQAAAEgBnjl0R/8AABpaNxXo1S77UmoqGaIPjtZ8Idg8jDcbYt82aJF75h52wT8qui9AGIZPgeQaJyIfyDqUN54wAeVxf3wNkvAsx4AAAAAxAZ47akf/AAAaEuMThMZQox3e5dUD7TIg8KLvuRaUrjSJ7JPDNJzqy4mOGUlrRLcqpwAAAHVBmiBJqEFsmUwIR//94QAAAwMOJymkykgFJMH9fX/AoffImJc104vU9PPrDScqoFw1lwS2XGP4ZnG51Z3+vBgY0jxZ0QlQt2lk1wQ/QuhO0b0DQ9RbTx/YOB5tzzwtg3/SrAu/b2vIv7G9WbGYFHBPJ8tc79EAAABpQZ5eRRUsI/8AABBVvkt8uz0uTAY27d8svk3QN6G6Wa7+JNgAIzSC+1tlVDiFC8KonaZbKwSw4aPiMW44/q46S4ce14MG0d9FbUcHzzyOluxGzSZDMWKs1Np31uPm9fx/O+A+3/1yMY78AAAAMQGefXRH/wAAGmlt0+k7buC6Ni0I4z9y/0SpDTlPR+M58fxV4Q/sAg/R4tSpLXTdYjwAAAA1AZ5/akf/AAAaXQlZLuR0YQRP9vOfyOv3WkA1VQCJttExmcgEDvAzjLZlhhIeYHIoxJjcC10AAABaQZpkSahBbJlMCEf//eEAAAMDE7/qZwwbp94YMXPB6mxL70gU5VySSzDfCAlk/Y9FKIpGW7sfQqalVR0VF3RLa5y7S7ym77H876EM/yLOuMet6GkTi9wybVdWAAAAVkGegkUVLCP/AAAQV/Gu401n/Begmfxve9hxaQdwF8U/hNljaHl/w34ZiM/BLtPiG6WfAUzBfcAATh01xsC+D+N50Mu8KWdLJFDJmaS/C0ok8LFh4/vRAAAAQgGeoXRH/wAAGmnvfZdtaAv/AqKsAy/McwcpLWTDEdXWegquy/GanPdtF8J+bwmm0dz2Y7/2a0Z7/b3gbA6023iy4AAAADoBnqNqR/8AABm9CuV+5z4Enpz1P0Sv6Bbs7vdYv1GoYe6KKEOgFlBY5UQJx4i/NeMpVIWmnhHNW3+9AAAARkGaqEmoQWyZTAj//IQAAAuaTCIulRbGfnFb0IEF2AAtv3b5EMRJbREIVeRitaxhxA09yRME4ekKu67hqkeiYM3Nr6ncubEAAABPQZ7GRRUsI/8AAA/XxXnMStJ0ZZZPUAHCIrIcOEzBhZmRM6TUpwOE44Fv25+G9tCr1c+X2osG9/dSPHGCltKdx0UrDwgySp9F5iZU1cilIQAAAC4BnuV0R/8AABm6dbhLY5joApqSgBJbGm2EWmJsXp/wWPV1XkXimhjQIFWDimAXAAAANAGe52pH/wAAGcgo5avOyi1eXnHhv/tACWGaYpXIanUhLd7ILf9g1636l7xrYr/uOmLcZQgAAAxnbW9vdgAAAGxtdmhkAAAAAAAAAAAAAAAAAAAD6AAAD7QAAQAAAQAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAC5F0cmFrAAAAXHRraGQAAAADAAAAAAAAAAAAAAABAAAAAAAAD7QAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAABAAAAAAlgAAAGQAAAAAAAkZWR0cwAAABxlbHN0AAAAAAAAAAEAAA+0AAACAAABAAAAAAsJbWRpYQAAACBtZGhkAAAAAAAAAAAAAAAAAAAyAAAAyQBVxAAAAAAALWhkbHIAAAAAAAAAAHZpZGUAAAAAAAAAAAAAAABWaWRlb0hhbmRsZXIAAAAKtG1pbmYAAAAUdm1oZAAAAAEAAAAAAAAAAAAAACRkaW5mAAAAHGRyZWYAAAAAAAAAAQAAAAx1cmwgAAAAAQAACnRzdGJsAAAAmHN0c2QAAAAAAAAAAQAAAIhhdmMxAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAlgBkABIAAAASAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGP//AAAAMmF2Y0MBZAAf/+EAGWdkAB+s2UCYM+XhAAADAAEAAAMAZA8YMZYBAAZo6+PLIsAAAAAYc3R0cwAAAAAAAAABAAAAyQAAAQAAAAAUc3RzcwAAAAAAAAABAAAAAQAABkBjdHRzAAAAAAAAAMYAAAABAAACAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAQAAAAAAgAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAAAwAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAEAAAAAAIAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAMAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAADAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAADAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAADAAAAAAEAAAEAAAAAAQAAAgAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAQAAAAAAgAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAAcc3RzYwAAAAAAAAABAAAAAQAAAMkAAAABAAADOHN0c3oAAAAAAAAAAAAAAMkAAATlAAAA1gAAAF8AAAA9AAAAOwAAAIoAAAA6AAAANgAAACsAAABSAAAAOAAAACUAAAAyAAAAZwAAAEAAAAAwAAAAOwAAAFoAAAA5AAAAMgAAACQAAABXAAAALgAAADUAAAAuAAAAUQAAADoAAAAsAAAAMgAAAEYAAABGAAAAIgAAACMAAABfAAAANwAAAC0AAAAzAAAAQgAAACQAAAAbAAAAUgAAACgAAAAdAAAANQAAAGwAAABAAAAALwAAACwAAABIAAAAOAAAAC0AAAAkAAAAbQAAACYAAAAwAAAAFwAAAFAAAAAvAAAAHgAAACYAAAAzAAAAIwAAAE4AAAAqAAAANAAAADQAAABxAAAANAAAACAAAAAyAAAAQwAAADoAAAAxAAAAUQAAAEMAAAAgAAAAMwAAAF8AAABHAAAAMAAAACAAAABzAAAATwAAAD4AAAAvAAAAhQAAAEsAAAApAAAAPgAAAGMAAAA8AAAARgAAAEsAAABkAAAASgAAADYAAAA2AAAAdwAAAE8AAAAzAAAARQAAAHUAAABJAAAARQAAADsAAABuAAAARQAAAFcAAABAAAAANgAAADUAAACHAAAAPgAAACwAAAAvAAAAiwAAAFsAAAA0AAAARAAAAKAAAAA8AAAAnQAAAFwAAABJAAAAQQAAAIgAAABlAAAAQQAAAE0AAACrAAAAYAAAAEEAAABNAAAAiQAAAHEAAABKAAAAUQAAAK0AAABUAAAAxgAAAHUAAABVAAAAUgAAAG0AAABRAAAAsQAAANYAAABjAAAARgAAAFkAAADKAAAAXQAAAGIAAABcAAAAkgAAAGQAAABLAAAATAAAAHsAAABhAAAATgAAAEQAAABtAAAAVAAAAEgAAAB1AAAAVQAAADoAAABJAAAAfAAAAE0AAAA0AAAAMwAAAGEAAABTAAAARQAAAEEAAABcAAAAVAAAADgAAAA+AAAAWgAAAEYAAABEAAAAPQAAAFwAAABOAAAATAAAADUAAAB5AAAAbQAAADUAAAA5AAAAXgAAAFoAAABGAAAAPgAAAEoAAABTAAAAMgAAADgAAAAUc3RjbwAAAAAAAAABAAAAMAAAAGJ1ZHRhAAAAWm1ldGEAAAAAAAAAIWhkbHIAAAAAAAAAAG1kaXJhcHBsAAAAAAAAAAAAAAAALWlsc3QAAAAlqXRvbwAAAB1kYXRhAAAAAQAAAABMYXZmNTcuODMuMTAw\" type=\"video/mp4\" />\n",
       "        </video>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import base64\n",
    "import glob\n",
    "import io\n",
    "import os\n",
    "\n",
    "from IPython.display import HTML, display\n",
    "\n",
    "\n",
    "def ipython_show_video(path: str) -> None:\n",
    "    \"\"\"Show a video at `path` within IPython Notebook.\"\"\"\n",
    "    if not os.path.isfile(path):\n",
    "        raise NameError(\"Cannot access: {}\".format(path))\n",
    "\n",
    "    video = io.open(path, \"r+b\").read()\n",
    "    encoded = base64.b64encode(video)\n",
    "\n",
    "    display(HTML(\n",
    "        data=\"\"\"\n",
    "        <video alt=\"test\" controls>\n",
    "        <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\"/>\n",
    "        </video>\n",
    "        \"\"\".format(encoded.decode(\"ascii\"))\n",
    "    ))\n",
    "\n",
    "list_of_files = glob.glob(\"videos/*.mp4\")\n",
    "latest_file = max(list_of_files, key=os.path.getctime)\n",
    "print(latest_file)\n",
    "ipython_show_video(latest_file)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
